#include <iostream>
#include <stdexcept>
using namespace std;


//节点结构：用于存储一段连续数据及关联的插入/嵌套节点信息
template <typename Data_Type, typename Num_Tpye>
struct FlexNode {
    //-----------本------------本数组整体数据。
    // 数据内容：动态分配的数组，存储实际元素
    Data_Type* data;  // 动态数组（运行时分配）
    // 容量：当前节点可容纳的最大元素数量（运行时确定）
    Num_Tpye size;    // 容量（运行时确定）
    // 本数组全部元素数量：当前节点实际存储的元素个数
    Num_Tpye total_quantity=0;


    //-----------插------------插入后的插入数据，诺是插入节点则没有。
    // 插入后,前半部分元素数量：当前节点插入元素后，前半部分的有效元素数
    Num_Tpye first_past_quantity=0;
    // 插入后,插入结构在本数组的下标，或指前半部分结束位置
    // Num_Tpye insertion_structure_subscript=0;    //不用，优化。
    // 插入后,插入结构的地址：指向插入在当前节点后的下一个节点（主链关联）
    FlexNode* next_node = nullptr;


    //-----------后------------插入后，父节点被砍的后半部分数据，诺是首节点则没有。
    //---本---父节点被砍的后半部分数据
    //插入后，父节点被砍的后半部分数据
    // 插入后,父节点后半部分元素数量：父节点拆分后，后半部分的元素数
    Num_Tpye later_past_quantity=0;                //不用，优化。
    // 插入后,父节点后半部分的地址
    // FlexNode* last_node;                //不用，优化。
    // 插入后,父节点后半部分开始的下标
    // Num_Tpye later_past_subscript=0;    //不用，优化。

    //---插---父节点被砍的后半部分数据 的插入后的插入数据，诺是插入节点则没有。
    // 父节点被砍的后半部分数据 插入后,前半部分元素数量：父节点后半部分插入元素后，前半部分的有效元素数
    Num_Tpye later_past_first_past_quantity=0;
    // 父节点被砍的后半部分数据 插入后,插入结构在本数组的下标，或指前半部分结束位置
    // Num_Tpye later_past_insertion_structure_subscript=0;    //不用，优化。
    // 父节点被砍的后半部分数据 插入后,插入结构的地址：指向父节点后半部分插入的节点（嵌套链关联）
    FlexNode* later_past_next_node = nullptr;

    // 构造函数：运行时传入节点容量，初始化动态数组
    // 参数s：节点的容量（即数组可容纳的元素数量）
    FlexNode(Num_Tpye s) : size(s), data(new Data_Type[s]) {}
    // 析构函数：释放动态数组占用的内存，避免内存泄漏
    ~FlexNode() { delete[] data; }
};


// 链表管理类：基于FlexNode的动态数组链表，负责节点的创建、释放及数据管理
template <typename Data_Type, typename Num_Tpye = unsigned short>
class FlexArray {
private:
    // 头节点：链表的第一个节点，作为整个链表的入口
    FlexNode<Data_Type, Num_Tpye>* head;
    // 节点容量（运行时确定）：所有节点统一的最大元素容纳量
    Num_Tpye node_size;


    // 静态成员函数：递归释放单个节点及其所有嵌套节点（替代lambda，解决递归问题）
    // 功能：从当前节点开始，先释放嵌套的later_past_next_node链，再释放主链next_node，确保所有关联节点都被释放
    // 参数node：待释放的节点指针（若为nullptr则直接返回）
    static void releaseNode(FlexNode<Data_Type, Num_Tpye>* node) {
        if (node == nullptr) return;  // 空节点无需释放，直接返回
        // 先释放嵌套的later_past_next_node链（处理父节点后半部分的关联节点）
        releaseNode(node->later_past_next_node);
        // 再释放主链next_node（处理当前节点后的关联节点）
        releaseNode(node->next_node);
        // 切断指针关联，避免释放后产生野指针
        node->next_node = nullptr;
        node->later_past_next_node = nullptr;
        // 释放当前节点（会自动调用FlexNode的析构函数，释放内部data数组）
        delete node;
    }

public:
    // 构造函数：初始化节点的指定范围元素（仅处理与[0, Size)重叠的中间有效范围）
    // 参数说明：
    //   Size：节点的容量（每个节点可容纳的最大元素数量）
    //   start：初始化范围的起始索引（左闭区间，默认0）
    //   end：初始化范围的结束索引（右开区间，默认0表示初始化全部元素）
    //   init_val：范围内元素的初始值（默认使用Data_Type的默认构造值，如int默认0）
    FlexArray(const auto Size,
              Num_Tpye start = 0,
              Num_Tpye end = 0,
              const Data_Type& init_val = Data_Type()) : node_size(Size) {
        try {
            // 创建头节点，分配容量为Size的动态数组
            head = new FlexNode<Data_Type, Num_Tpye>(Size);
            // 仅当节点容量大于0时，才进行元素初始化（容量为0时无需处理）
            if (Size > 0) {
                // 处理默认范围：若未指定end（或end=0），默认初始化全部元素（[0, Size)）
                if (end == 0) {
                    end = Size;
                }

                // 自动计算有效范围（与[0, Size)的交集，处理越界情况）
                Num_Tpye valid_start = (start < 0) ? 0 : start;  // 若start为负数，从0开始
                Num_Tpye valid_end = (end > Size) ? Size : end;   // 若end超过容量，到Size结束
                valid_start = (valid_start > valid_end) ? valid_end : valid_start;  // 确保start <= end

                // 初始化元素：有效范围内用init_val，其他位置用默认值
                for (Num_Tpye i = 0; i < Size; ++i) {
                    if (i >= valid_start && i < valid_end) {  // 只处理有效范围
                        head->data[i] = init_val;
                    } else {
                        head->data[i] = Data_Type();  // 范围外/无效范围用默认值
                    }
                }
                // 初始化后，节点的元素总数等于容量（所有位置均有值）
                head->total_quantity = Size;
            } else {
                // 容量为0时，元素数量为0
                head->total_quantity = 0;
            }
        } catch (const std::bad_alloc& e) {  // 捕获内存分配失败异常
            cerr << "Memory allocation failed: " << e.what() << ". Please reduce the node size!" << endl;
            exit(1);  // 分配失败时退出程序，避免后续错误
        }
    };


    // 析构函数：释放所有节点（包括 next_node主链 和 later_past_next_node嵌套链 中的所有节点）
    ~FlexArray() {
        // 从 head 开始，释放整个链表的所有节点（包括所有嵌套关系）
        releaseNode(head);
        head = nullptr;  // 彻底置空头指针，避免野指针
    };


    //插入函数：预留接口，用于后续实现元素插入逻辑（如节点内插入、节点拆分插入等）
    int insert(auto position,auto value) {

    };

};


// 测试代码
int main() {
    // 创建一个元素类型为int、计数类型为unsigned long long、节点容量为3000000的FlexArray
    // （节点容量较大，需确保系统内存充足）
    FlexArray<char, unsigned long long> flexArr(3000000,0,0,3.3);


    return 0;
}